package com.photography.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.photography.common.Result;
import com.photography.entity.Category;
import com.photography.entity.Product;
import com.photography.entity.User;
import com.photography.exception.ErrorCode;
import com.photography.mapper.CategoryMapper;
import com.photography.service.CategoryService;
import com.photography.service.ProductService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.*;


@Service
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {

    @Resource
    private ProductService productService;
    /**
     * 新增产品分类
     *
     * @param category 分类信息
     * @return 结果
     */
    @Override
    public Result addCategory(Category category) {
        // 验证必填字段
        if (category.getCategoryName() == null || category.getCategoryName().trim().isEmpty()) {
            return Result.error("分类名称不能为空");
        }
        if (category.getCategoryTitle() == null || category.getCategoryTitle().trim().isEmpty()) {
            return Result.error("分类描述不能为空");
        }
        if (category.getDisplayArea() == null || category.getDisplayArea().trim().isEmpty()) {
            return Result.error("分类展示区域不能为空");
        }

        Category findCategory= this.getOne(
                new QueryWrapper<Category>().eq("category_name", category.getCategoryName())
        );
        if (findCategory !=null){
            return Result.error("分类名已被使用");
        }

        boolean result = this.save(category);
        if (result) {
            return Result.success(category, "添加产品分类成功");
        } else {
            return Result.error("添加产品分类失败");
        }
    }

    /**
     * 删除分类
     *
     * @param id 分类id
     * @return 结果
     */
    @Override
    public Result deleteCategory(Integer id) {
//        验证产品分类ID
        if (id == null) {
            return Result.error("产品分类ID不能为空");
        }

        // 检查产品是否存在
        Category existingProduct = this.getById(id);
        if (existingProduct == null) {
            return Result.error("产品分类不存在");
        }

        boolean result = this.removeById(id);
        if (result) {
            return Result.success(null, "删除产品分类成功");
        } else {
            return Result.error("删除产品分类失败");
        }
    }

    /**
     * 更新产品分类信息
     * @param category 产品分类信息
     * @return 结果
     */
    @Override
    public Result updateCategory(Category category) {
        if (category.getId()==null){
            return Result.error("分类id不能为空",ErrorCode.PARAM_EMPTY.getCode());
        }
        Category findCategory=this.getById(category.getId());
        if (findCategory==null){
            return Result.error("产品分类不存在");
        }

        boolean result=this.updateById(category);
        if (result){
            return Result.success(category,"更新成功");
        } else {
            return Result.error("更新失败");
        }
    }

    /**
     * 分页查询分类
     *
     * @param page        分页参数
     * @param displayArea 显示区域（可选）
     * @param search 模糊搜索，支持分类名、分类标题、展示区域
     * @return 结果
     */
    @Override
    public Page<Category> getCategoryPage(Page<Category> page, String displayArea,String search) {
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        if (StringUtils.hasText(displayArea)) {
            queryWrapper.like(Category::getDisplayArea, displayArea);
        }
        if (StringUtils.hasText(search)){
            queryWrapper .like(Category::getCategoryName, search)
                    .or()
                    .like(Category::getCategoryTitle, search)
                    .or()
                    .like(Category::getDisplayArea, search)
                    .or();
        }
        return page(page, queryWrapper);
    }


    /**
     * 模糊搜索
     *
     * @param page    分页参数
     * @param keyword 搜索关键词，支持分类名、分类标题、展示区域
     * @return 结果
     */
    @Override
    public Page<Category> search(Page<Category> page, String keyword) {
        if (!StringUtils.hasText(keyword)) {
            return new Page<>(page.getCurrent(), page.getSize());
        }

        // 创建查询条件
        LambdaQueryWrapper<Category> wrapper = new LambdaQueryWrapper<Category>()
                .like(Category::getCategoryName, keyword)
                .or()
                .like(Category::getCategoryTitle, keyword)
                .or()
                .like(Category::getDisplayArea, keyword)
                .or();

        // 执行分页查询
        return this.page(page, wrapper);
    }


    /**
     * 查询所有分类及其下的产品
     * @param displayArea 显示区域
     * @return 结果
     */
    @Override
    public Result findAllWithProducts(String displayArea) {
        //查询所有分类
        List<Category> categories=this.list();
        //查询所有产品
        List<Product> products=productService.list();

        // 构建分类及其产品的树形结构
        List<Map<String, Object>> result = new ArrayList<>();
        for (Category category : categories) {
            // 如果displayArea不为空，则只保留符合displayArea值的分类
            if (displayArea != null && !displayArea.equals(category.getDisplayArea())) {
                continue;
            }
            Map<String, Object> categoryMap = new HashMap<>();
            categoryMap.put("id", category.getId());
            categoryMap.put("categoryName", category.getCategoryName());
            categoryMap.put("categoryTitle", category.getCategoryTitle());
            categoryMap.put("displayArea", category.getDisplayArea());
            // 查找该分类下的所有产品
            List<Product> categoryProducts = new ArrayList<>();
            for (Product product : products) {
                if (product.getCategory() != null && product.getCategory().equals(category.getCategoryName())) {
                    categoryProducts.add(product);
                }
            }

            result.add(categoryMap);
            // 将产品列表添加到分类的children属性中
            categoryMap.put("children", categoryProducts);
        }
        return Result.success(result,"查询成功");
    }

    /**
     * 查询指定分类及其下的产品
     * @param id 分类ID
     * @return 分类及其产品
     */
    @Override
    public Result findCategoryWithProducts(Integer id) {
        // 查询指定分类
        Category category = this.getById(id);
        if (category == null) {
            return Result.error("分类不存在", ErrorCode.PARAM_ERROR.getCode());
        }
        // 查询该分类下的产品
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Product::getCategory, category.getCategoryName());
        List<Product> products = productService.list(queryWrapper);
        // 构建返回结构
        Map<String, Object> categoryMap = new HashMap<>();
        categoryMap.put("id", category.getId());
        categoryMap.put("categoryName", category.getCategoryName());
        categoryMap.put("categoryTitle", category.getCategoryTitle());
        categoryMap.put("children", products);
        return Result.success(categoryMap);
    }
}
